package org.wdcode.back.helper;

import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentMap;

import org.wdcode.back.cache.OperateCache;
import org.wdcode.back.params.WdBackParams;
import org.wdcode.back.po.Operate;
import org.wdcode.back.po.RoleOperate;
import org.wdcode.back.po.User;
import org.wdcode.base.helper.BaseEntityCacheHelper;
import org.wdcode.base.util.Struts2Util;

import org.wdcode.common.tools.Lists;
import org.wdcode.common.tools.Maps;

/**
 * 操作相关业务助手类 可操作缓存
 * @author WD
 * @since JDK6
 * @version 1.0 2009-11-23
 */
public final class OperateHelper extends BaseEntityCacheHelper<OperateCache, Operate> {
	// 操作助手
	private static OperateHelper					helper;
	// 用户权限列表
	private ConcurrentMap<Integer, List<Integer>>	userOperate;

	/**
	 * 构造方法
	 */
	public OperateHelper() {
		userOperate = Maps.getConcurrenrMap();
	}

	/**
	 * 设置用户权限列表
	 * @param key 键
	 * @param operate 用户权限
	 */
	public void setUserOperate(int key, List<Integer> operate) {
		userOperate.put(key, operate);
	}

	/**
	 * 设置用户权限列表
	 * @param uid 用户ID
	 * @param operate 用户权限
	 */
	public List<Integer> getUserOperate(int uid) {
		// 返回权限列表
		return userOperate.get(uid);
	}

	/**
	 * 根据角色获得操作ID列表
	 * @return 操作ID列表
	 */
	public List<Operate> getByRole(int role) {
		// 声明列表保存操作
		List<Operate> list = Lists.getList();
		// 获得角色与操作关系缓存
		Map<Integer, RoleOperate> map = RoleOperateHelper.getHelper().getCaches();
		// 声明角色与操作关系 保存临时变量
		RoleOperate ro = null;
		// 循环
		for (Map.Entry<Integer, RoleOperate> entry : map.entrySet()) {
			// 获得角色与操作关系
			ro = entry.getValue();
			// 判断是否是这个角色的
			if (role == ro.getRoleId()) {
				// 是 添加到列表
				list.add(get(ro.getOperateId()));
			}
		}
		// 返回列表
		return Lists.sort(list);
	}

	/**
	 * 获得这个列表没有的数据
	 * @param list 不要的数据
	 * @return 列表
	 */
	public List<Operate> getNotList(List<Operate> list) {
		// 获得全部列表
		List<Operate> all = getList();
		// 删除不要的
		all.removeAll(list);
		// 返回列表
		return Lists.sort(all);
	}

	/**
	 * 根据link获得操作实体,link包含实体的link包含就返回
	 * @param link 连接
	 * @return
	 */
	public Operate getByLink(String link) {
		// 获得操作列表
		List<Operate> lsOperate = Lists.getList(getCache().getCaches().values());
		// 声明一个操作实体 保存临时对象
		Operate operate = null;
		// 循环操作列表
		for (int i = 0; i < lsOperate.size(); i++) {
			// 获得操作对象
			operate = lsOperate.get(i);
			// 判断对象 包含这个link
			if (link.indexOf(operate.getLink()) > -1) {
				// 返回对象
				return operate;
			}
		}
		// 返回null
		return getInstance();
	}

	/**
	 * 判断是否有权限
	 * @return 是否有权限
	 */
	public boolean isRights() {
		return isRights(Struts2Util.getRequest().getServletPath());
	}

	/**
	 * 判断是否有权限
	 * @param url 提交的URL
	 * @return 是否有权限
	 */
	public boolean isRights(String url) {
		// 获得用户实体
		User user = UserHelper.getHelper().getUser();
		// 判断不是所有权限
		if (user.getId() == WdBackParams.getRoleAll()) {
			// 所有权限 返回
			return true;
		} else {
			// 获得自己的权限列表
			List<Integer> lsOperate = getUserOperate(user.getId());
			// 不是所有权限 继续判断
			return lsOperate.contains(getByLink(url).getId());
		}
	}

	/**
	 * 实例化一个对象
	 */
	public Operate newInstance() {
		return new Operate();
	}

	/**
	 * 获得子类的Class
	 * @return 子类的Class
	 */
	public Class<Operate> getEntityClass() {
		return Operate.class;
	}

	/**
	 * 获得操作助手
	 * @return 操作助手
	 */
	public static OperateHelper getHelper() {
		return helper;
	}

	/**
	 * 设置操作助手
	 * @param helper 操作助手
	 */
	public void setHelper(OperateHelper helper) {
		OperateHelper.helper = helper;
	}
}
